home *** CD-ROM | disk | FTP | other *** search
/ Freelog 100 / FreelogNo100-NovembreDecembre2010.iso / Musique / solfege / solfege-win32-3.17.0.exe / {app} / bin / Lib / sre_compile.py < prev    next >
Text File  |  2008-01-21  |  17KB  |  532 lines
  1. #
  2. # Secret Labs' Regular Expression Engine
  3. #
  4. # convert template to internal format
  5. #
  6. # Copyright (c) 1997-2001 by Secret Labs AB.  All rights reserved.
  7. #
  8. # See the sre.py file for information on usage and redistribution.
  9. #
  10.  
  11. """Internal support module for sre"""
  12.  
  13. import _sre, sys
  14.  
  15. from sre_constants import *
  16.  
  17. assert _sre.MAGIC == MAGIC, "SRE module mismatch"
  18.  
  19. if _sre.CODESIZE == 2:
  20.     MAXCODE = 65535
  21. else:
  22.     MAXCODE = 0xFFFFFFFFL
  23.  
  24. def _identityfunction(x):
  25.     return x
  26.  
  27. def set(seq):
  28.     s = {}
  29.     for elem in seq:
  30.         s[elem] = 1
  31.     return s
  32.  
  33. _LITERAL_CODES = set([LITERAL, NOT_LITERAL])
  34. _REPEATING_CODES = set([REPEAT, MIN_REPEAT, MAX_REPEAT])
  35. _SUCCESS_CODES = set([SUCCESS, FAILURE])
  36. _ASSERT_CODES = set([ASSERT, ASSERT_NOT])
  37.  
  38. def _compile(code, pattern, flags):
  39.     # internal: compile a (sub)pattern
  40.     emit = code.append
  41.     _len = len
  42.     LITERAL_CODES = _LITERAL_CODES
  43.     REPEATING_CODES = _REPEATING_CODES
  44.     SUCCESS_CODES = _SUCCESS_CODES
  45.     ASSERT_CODES = _ASSERT_CODES
  46.     for op, av in pattern:
  47.         if op in LITERAL_CODES:
  48.             if flags & SRE_FLAG_IGNORECASE:
  49.                 emit(OPCODES[OP_IGNORE[op]])
  50.                 emit(_sre.getlower(av, flags))
  51.             else:
  52.                 emit(OPCODES[op])
  53.                 emit(av)
  54.         elif op is IN:
  55.             if flags & SRE_FLAG_IGNORECASE:
  56.                 emit(OPCODES[OP_IGNORE[op]])
  57.                 def fixup(literal, flags=flags):
  58.                     return _sre.getlower(literal, flags)
  59.             else:
  60.                 emit(OPCODES[op])
  61.                 fixup = _identityfunction
  62.             skip = _len(code); emit(0)
  63.             _compile_charset(av, flags, code, fixup)
  64.             code[skip] = _len(code) - skip
  65.         elif op is ANY:
  66.             if flags & SRE_FLAG_DOTALL:
  67.                 emit(OPCODES[ANY_ALL])
  68.             else:
  69.                 emit(OPCODES[ANY])
  70.         elif op in REPEATING_CODES:
  71.             if flags & SRE_FLAG_TEMPLATE:
  72.                 raise error, "internal: unsupported template operator"
  73.                 emit(OPCODES[REPEAT])
  74.                 skip = _len(code); emit(0)
  75.                 emit(av[0])
  76.                 emit(av[1])
  77.                 _compile(code, av[2], flags)
  78.                 emit(OPCODES[SUCCESS])
  79.                 code[skip] = _len(code) - skip
  80.             elif _simple(av) and op is not REPEAT:
  81.                 if op is MAX_REPEAT:
  82.                     emit(OPCODES[REPEAT_ONE])
  83.                 else:
  84.                     emit(OPCODES[MIN_REPEAT_ONE])
  85.                 skip = _len(code); emit(0)
  86.                 emit(av[0])
  87.                 emit(av[1])
  88.                 _compile(code, av[2], flags)
  89.                 emit(OPCODES[SUCCESS])
  90.                 code[skip] = _len(code) - skip
  91.             else:
  92.                 emit(OPCODES[REPEAT])
  93.                 skip = _len(code); emit(0)
  94.                 emit(av[0])
  95.                 emit(av[1])
  96.                 _compile(code, av[2], flags)
  97.                 code[skip] = _len(code) - skip
  98.                 if op is MAX_REPEAT:
  99.                     emit(OPCODES[MAX_UNTIL])
  100.                 else:
  101.                     emit(OPCODES[MIN_UNTIL])
  102.         elif op is SUBPATTERN:
  103.             if av[0]:
  104.                 emit(OPCODES[MARK])
  105.                 emit((av[0]-1)*2)
  106.             # _compile_info(code, av[1], flags)
  107.             _compile(code, av[1], flags)
  108.             if av[0]:
  109.                 emit(OPCODES[MARK])
  110.                 emit((av[0]-1)*2+1)
  111.         elif op in SUCCESS_CODES:
  112.             emit(OPCODES[op])
  113.         elif op in ASSERT_CODES:
  114.             emit(OPCODES[op])
  115.             skip = _len(code); emit(0)
  116.             if av[0] >= 0:
  117.                 emit(0) # look ahead
  118.             else:
  119.                 lo, hi = av[1].getwidth()
  120.                 if lo != hi:
  121.                     raise error, "look-behind requires fixed-width pattern"
  122.                 emit(lo) # look behind
  123.             _compile(code, av[1], flags)
  124.             emit(OPCODES[SUCCESS])
  125.             code[skip] = _len(code) - skip
  126.         elif op is CALL:
  127.             emit(OPCODES[op])
  128.             skip = _len(code); emit(0)
  129.             _compile(code, av, flags)
  130.             emit(OPCODES[SUCCESS])
  131.             code[skip] = _len(code) - skip
  132.         elif op is AT:
  133.             emit(OPCODES[op])
  134.             if flags & SRE_FLAG_MULTILINE:
  135.                 av = AT_MULTILINE.get(av, av)
  136.             if flags & SRE_FLAG_LOCALE:
  137.                 av = AT_LOCALE.get(av, av)
  138.             elif flags & SRE_FLAG_UNICODE:
  139.                 av = AT_UNICODE.get(av, av)
  140.             emit(ATCODES[av])
  141.         elif op is BRANCH:
  142.             emit(OPCODES[op])
  143.             tail = []
  144.             tailappend = tail.append
  145.             for av in av[1]:
  146.                 skip = _len(code); emit(0)
  147.                 # _compile_info(code, av, flags)
  148.                 _compile(code, av, flags)
  149.                 emit(OPCODES[JUMP])
  150.                 tailappend(_len(code)); emit(0)
  151.                 code[skip] = _len(code) - skip
  152.             emit(0) # end of branch
  153.             for tail in tail:
  154.                 code[tail] = _len(code) - tail
  155.         elif op is CATEGORY:
  156.             emit(OPCODES[op])
  157.             if flags & SRE_FLAG_LOCALE:
  158.                 av = CH_LOCALE[av]
  159.             elif flags & SRE_FLAG_UNICODE:
  160.                 av = CH_UNICODE[av]
  161.             emit(CHCODES[av])
  162.         elif op is GROUPREF:
  163.             if flags & SRE_FLAG_IGNORECASE:
  164.                 emit(OPCODES[OP_IGNORE[op]])
  165.             else:
  166.                 emit(OPCODES[op])
  167.             emit(av-1)
  168.         elif op is GROUPREF_EXISTS:
  169.             emit(OPCODES[op])
  170.             emit(av[0]-1)
  171.             skipyes = _len(code); emit(0)
  172.             _compile(code, av[1], flags)
  173.             if av[2]:
  174.                 emit(OPCODES[JUMP])
  175.                 skipno = _len(code); emit(0)
  176.                 code[skipyes] = _len(code) - skipyes + 1
  177.                 _compile(code, av[2], flags)
  178.                 code[skipno] = _len(code) - skipno
  179.             else:
  180.                 code[skipyes] = _len(code) - skipyes + 1
  181.         else:
  182.             raise ValueError, ("unsupported operand type", op)
  183.  
  184. def _compile_charset(charset, flags, code, fixup=None):
  185.     # compile charset subprogram
  186.     emit = code.append
  187.     if fixup is None:
  188.         fixup = _identityfunction
  189.     for op, av in _optimize_charset(charset, fixup):
  190.         emit(OPCODES[op])
  191.         if op is NEGATE:
  192.             pass
  193.         elif op is LITERAL:
  194.             emit(fixup(av))
  195.         elif op is RANGE:
  196.             emit(fixup(av[0]))
  197.             emit(fixup(av[1]))
  198.         elif op is CHARSET:
  199.             code.extend(av)
  200.         elif op is BIGCHARSET:
  201.             code.extend(av)
  202.         elif op is CATEGORY:
  203.             if flags & SRE_FLAG_LOCALE:
  204.                 emit(CHCODES[CH_LOCALE[av]])
  205.             elif flags & SRE_FLAG_UNICODE:
  206.                 emit(CHCODES[CH_UNICODE[av]])
  207.             else:
  208.                 emit(CHCODES[av])
  209.         else:
  210.             raise error, "internal: unsupported set operator"
  211.     emit(OPCODES[FAILURE])
  212.  
  213. def _optimize_charset(charset, fixup):
  214.     # internal: optimize character set
  215.     out = []
  216.     outappend = out.append
  217.     charmap = [0]*256
  218.     try:
  219.         for op, av in charset:
  220.             if op is NEGATE:
  221.                 outappend((op, av))
  222.             elif op is LITERAL:
  223.                 charmap[fixup(av)] = 1
  224.             elif op is RANGE:
  225.                 for i in range(fixup(av[0]), fixup(av[1])+1):
  226.                     charmap[i] = 1
  227.             elif op is CATEGORY:
  228.                 # XXX: could append to charmap tail
  229.                 return charset # cannot compress
  230.     except IndexError:
  231.         # character set contains unicode characters
  232.         return _optimize_unicode(charset, fixup)
  233.     # compress character map
  234.     i = p = n = 0
  235.     runs = []
  236.     runsappend = runs.append
  237.     for c in charmap:
  238.         if c:
  239.             if n == 0:
  240.                 p = i
  241.             n = n + 1
  242.         elif n:
  243.             runsappend((p, n))
  244.             n = 0
  245.         i = i + 1
  246.     if n:
  247.         runsappend((p, n))
  248.     if len(runs) <= 2:
  249.         # use literal/range
  250.         for p, n in runs:
  251.             if n == 1:
  252.                 outappend((LITERAL, p))
  253.             else:
  254.                 outappend((RANGE, (p, p+n-1)))
  255.         if len(out) < len(charset):
  256.             return out
  257.     else:
  258.         # use bitmap
  259.         data = _mk_bitmap(charmap)
  260.         outappend((CHARSET, data))
  261.         return out
  262.     return charset
  263.  
  264. def _mk_bitmap(bits):
  265.     data = []
  266.     dataappend = data.append
  267.     if _sre.CODESIZE == 2:
  268.         start = (1, 0)
  269.     else:
  270.         start = (1L, 0L)
  271.     m, v = start
  272.     for c in bits:
  273.         if c:
  274.             v = v + m
  275.         m = m + m
  276.         if m > MAXCODE:
  277.             dataappend(v)
  278.             m, v = start
  279.     return data
  280.  
  281. # To represent a big charset, first a bitmap of all characters in the
  282. # set is constructed. Then, this bitmap is sliced into chunks of 256
  283. # characters, duplicate chunks are eliminated, and each chunk is
  284. # given a number. In the compiled expression, the charset is
  285. # represented by a 16-bit word sequence, consisting of one word for
  286. # the number of different chunks, a sequence of 256 bytes (128 words)
  287. # of chunk numbers indexed by their original chunk position, and a
  288. # sequence of chunks (16 words each).
  289.  
  290. # Compression is normally good: in a typical charset, large ranges of
  291. # Unicode will be either completely excluded (e.g. if only cyrillic
  292. # letters are to be matched), or completely included (e.g. if large
  293. # subranges of Kanji match). These ranges will be represented by
  294. # chunks of all one-bits or all zero-bits.
  295.  
  296. # Matching can be also done efficiently: the more significant byte of
  297. # the Unicode character is an index into the chunk number, and the
  298. # less significant byte is a bit index in the chunk (just like the
  299. # CHARSET matching).
  300.  
  301. # In UCS-4 mode, the BIGCHARSET opcode still supports only subsets
  302. # of the basic multilingual plane; an efficient representation
  303. # for all of UTF-16 has not yet been developed. This means,
  304. # in particular, that negated charsets cannot be represented as
  305. # bigcharsets.
  306.  
  307. def _optimize_unicode(charset, fixup):
  308.     try:
  309.         import array
  310.     except ImportError:
  311.         return charset
  312.     charmap = [0]*65536
  313.     negate = 0
  314.     try:
  315.         for op, av in charset:
  316.             if op is NEGATE:
  317.                 negate = 1
  318.             elif op is LITERAL:
  319.                 charmap[fixup(av)] = 1
  320.             elif op is RANGE:
  321.                 for i in xrange(fixup(av[0]), fixup(av[1])+1):
  322.                     charmap[i] = 1
  323.             elif op is CATEGORY:
  324.                 # XXX: could expand category
  325.                 return charset # cannot compress
  326.     except IndexError:
  327.         # non-BMP characters
  328.         return charset
  329.     if negate:
  330.         if sys.maxunicode != 65535:
  331.             # XXX: negation does not work with big charsets
  332.             return charset
  333.         for i in xrange(65536):
  334.             charmap[i] = not charmap[i]
  335.     comps = {}
  336.     mapping = [0]*256
  337.     block = 0
  338.     data = []
  339.     for i in xrange(256):
  340.         chunk = tuple(charmap[i*256:(i+1)*256])
  341.         new = comps.setdefault(chunk, block)
  342.         mapping[i] = new
  343.         if new == block:
  344.             block = block + 1
  345.             data = data + _mk_bitmap(chunk)
  346.     header = [block]
  347.     if _sre.CODESIZE == 2:
  348.         code = 'H'
  349.     else:
  350.         code = 'I'
  351.     # Convert block indices to byte array of 256 bytes
  352.     mapping = array.array('b', mapping).tostring()
  353.     # Convert byte array to word array
  354.     mapping = array.array(code, mapping)
  355.     assert mapping.itemsize == _sre.CODESIZE
  356.     header = header + mapping.tolist()
  357.     data[0:0] = header
  358.     return [(BIGCHARSET, data)]
  359.  
  360. def _simple(av):
  361.     # check if av is a "simple" operator
  362.     lo, hi = av[2].getwidth()
  363.     if lo == 0 and hi == MAXREPEAT:
  364.         raise error, "nothing to repeat"
  365.     return lo == hi == 1 and av[2][0][0] != SUBPATTERN
  366.  
  367. def _compile_info(code, pattern, flags):
  368.     # internal: compile an info block.  in the current version,
  369.     # this contains min/max pattern width, and an optional literal
  370.     # prefix or a character map
  371.     lo, hi = pattern.getwidth()
  372.     if lo == 0:
  373.         return # not worth it
  374.     # look for a literal prefix
  375.     prefix = []
  376.     prefixappend = prefix.append
  377.     prefix_skip = 0
  378.     charset = [] # not used
  379.     charsetappend = charset.append
  380.     if not (flags & SRE_FLAG_IGNORECASE):
  381.         # look for literal prefix
  382.         for op, av in pattern.data:
  383.             if op is LITERAL:
  384.                 if len(prefix) == prefix_skip:
  385.                     prefix_skip = prefix_skip + 1
  386.                 prefixappend(av)
  387.             elif op is SUBPATTERN and len(av[1]) == 1:
  388.                 op, av = av[1][0]
  389.                 if op is LITERAL:
  390.                     prefixappend(av)
  391.                 else:
  392.                     break
  393.             else:
  394.                 break
  395.         # if no prefix, look for charset prefix
  396.         if not prefix and pattern.data:
  397.             op, av = pattern.data[0]
  398.             if op is SUBPATTERN and av[1]:
  399.                 op, av = av[1][0]
  400.                 if op is LITERAL:
  401.                     charsetappend((op, av))
  402.                 elif op is BRANCH:
  403.                     c = []
  404.                     cappend = c.append
  405.                     for p in av[1]:
  406.                         if not p:
  407.                             break
  408.                         op, av = p[0]
  409.                         if op is LITERAL:
  410.                             cappend((op, av))
  411.                         else:
  412.                             break
  413.                     else:
  414.                         charset = c
  415.             elif op is BRANCH:
  416.                 c = []
  417.                 cappend = c.append
  418.                 for p in av[1]:
  419.                     if not p:
  420.                         break
  421.                     op, av = p[0]
  422.                     if op is LITERAL:
  423.                         cappend((op, av))
  424.                     else:
  425.                         break
  426.                 else:
  427.                     charset = c
  428.             elif op is IN:
  429.                 charset = av
  430. ##     if prefix:
  431. ##         print "*** PREFIX", prefix, prefix_skip
  432. ##     if charset:
  433. ##         print "*** CHARSET", charset
  434.     # add an info block
  435.     emit = code.append
  436.     emit(OPCODES[INFO])
  437.     skip = len(code); emit(0)
  438.     # literal flag
  439.     mask = 0
  440.     if prefix:
  441.         mask = SRE_INFO_PREFIX
  442.         if len(prefix) == prefix_skip == len(pattern.data):
  443.             mask = mask + SRE_INFO_LITERAL
  444.     elif charset:
  445.         mask = mask + SRE_INFO_CHARSET
  446.     emit(mask)
  447.     # pattern length
  448.     if lo < MAXCODE:
  449.         emit(lo)
  450.     else:
  451.         emit(MAXCODE)
  452.         prefix = prefix[:MAXCODE]
  453.     if hi < MAXCODE:
  454.         emit(hi)
  455.     else:
  456.         emit(0)
  457.     # add literal prefix
  458.     if prefix:
  459.         emit(len(prefix)) # length
  460.         emit(prefix_skip) # skip
  461.         code.extend(prefix)
  462.         # generate overlap table
  463.         table = [-1] + ([0]*len(prefix))
  464.         for i in xrange(len(prefix)):
  465.             table[i+1] = table[i]+1
  466.             while table[i+1] > 0 and prefix[i] != prefix[table[i+1]-1]:
  467.                 table[i+1] = table[table[i+1]-1]+1
  468.         code.extend(table[1:]) # don't store first entry
  469.     elif charset:
  470.         _compile_charset(charset, flags, code)
  471.     code[skip] = len(code) - skip
  472.  
  473. try:
  474.     unicode
  475. except NameError:
  476.     STRING_TYPES = (type(""),)
  477. else:
  478.     STRING_TYPES = (type(""), type(unicode("")))
  479.  
  480. def isstring(obj):
  481.     for tp in STRING_TYPES:
  482.         if isinstance(obj, tp):
  483.             return 1
  484.     return 0
  485.  
  486. def _code(p, flags):
  487.  
  488.     flags = p.pattern.flags | flags
  489.     code = []
  490.  
  491.     # compile info block
  492.     _compile_info(code, p, flags)
  493.  
  494.     # compile the pattern
  495.     _compile(code, p.data, flags)
  496.  
  497.     code.append(OPCODES[SUCCESS])
  498.  
  499.     return code
  500.  
  501. def compile(p, flags=0):
  502.     # internal: convert pattern list to internal format
  503.  
  504.     if isstring(p):
  505.         import sre_parse
  506.         pattern = p
  507.         p = sre_parse.parse(p, flags)
  508.     else:
  509.         pattern = None
  510.  
  511.     code = _code(p, flags)
  512.  
  513.     # print code
  514.  
  515.     # XXX: <fl> get rid of this limitation!
  516.     if p.pattern.groups > 100:
  517.         raise AssertionError(
  518.             "sorry, but this version only supports 100 named groups"
  519.             )
  520.  
  521.     # map in either direction
  522.     groupindex = p.pattern.groupdict
  523.     indexgroup = [None] * p.pattern.groups
  524.     for k, i in groupindex.items():
  525.         indexgroup[i] = k
  526.  
  527.     return _sre.compile(
  528.         pattern, flags | p.pattern.flags, code,
  529.         p.pattern.groups-1,
  530.         groupindex, indexgroup
  531.         )
  532.